The MASTERMIND User Interface Generation Project

Graphical user interfaces are difficult to construct and, consequently, suffer from high development and maintenance costs. Automatic generation from declarative descriptions can reduce costs and enforce design principles. MASTERMIND is a model based approach to user interface generation. Designers model different aspects of an interface using declarative modeling languages, and tools synthesize these models into run-time code. The design process begins with user task and application modeling. These models are then refined into dialogue, presentation, and interaction models and an application API. These latter models drive the synthesis of run-time code. A design tool called Dukas is employed to support the refinement of task models into dialogue models

Dissertation: Automatic Generation of Interactive Systems from Declarative Models

This dissertation applies formal methods to the automatic generation of interactive systems from multiple declarative models. We are interested in two kinds of models: user-task and presentation. The MASTERMIND Dialogue Language (MDL) is presented. MDL is a notation for describing interactive system behavior in terms of user tasks. MDL task models are expressed independently of other models, like presentation, but are later composed with the behavior of these other models. Such separation is important for preserving the integrity of models over the lifetime of a system. The technical challenge in this approach is to generate code that combines the functionality of task and presentation models without violating that integrity. To meet this challenge we implement MDL task models as run-time dialogue constraints that synchronize with presentation components. The constraint engine is implemented as a virtual machine that simulates the execution of tasks and resolves the dependencies that arise as a result of task and presentation model composition. To simplify the generation process, a toolkit of reusable run-time components is provided. Each component in this toolkit implements an MDL operator, and components aggregate into trees whose structure corresponds one-to-one with the abstract syntax tree of a corresponding MDL model. Thus implementations can be generated through a simple syntactic transformation of the MDL source code. The design correctness of these components is validated by a novel application of symbolic model checking. The run-time attributes of systems generated using this approach are measured, and we conclude that this strategy of model composition is feasible for use with real interactive systems

Automatic generation of interactive systems from declarative models

Ph.D.Spencer Rugabe

The Design and Implementation of the MASTERMIND Toolkit (MMTK)

The MASTERMIND project is concerned with the design, integration, and automatic generation of interactive systems from declarative models. One model describes the tasks a user will perform as a protocol of end user actions and their affect on other aspects of the application. The MASTERMIND Dialogue Language (MDL) is a declarative notation for specifying user tasks. The MASTERMIND Toolkit (MMTK) is a run-time infrastructure and collection of reusable C++ components which can be instantiated and aggregated to implement MDL specifications. Code generators implement an MDL behavior expression E by aggregating MMTK components (representing the various operators within E) into a class and connecting these components according to the syntactic structure of E. This approach distributes the control policy of an MDL operator over many independent components. These components implement orderings by issuing control commands to sub-ordinate components and announcing activity and status to parent components in a tree hierarchy. We designed these components around a model of machine execution in which each component is independent and may (/em message) other components without waiting for them to return. This document outlines our design

DARPA Dynamic Assembly for System Adaptability, Dependability, and Assurance Program

The DYNAMO project is concerned with assembling high-assurance systems from components, and, specifically, with guaranteeing correct interaction of sets of large, heterogeneous components. Several problems must be overcome to provide such guarantees: 1) dealing with the sheer complexity of the individual components and their interoperation; 2) maintaining design integrity and information hiding in the individual components; 3) providing the desired guarantees; and 4) not compromising efficiency while accomplishing the other goals. DYNAMO addresses these problems with several techniques: 1) a layered, implicit-invocation architecture limits complexity by reducing the quantity and nature of allowed interactions; 2) a declarative specification mechanism abstracts away low-level details such as event dispatch and handling and variable updates; and 3) compile- time component wrapper generation removes expensive, inter-layer procedure calls

Automating UI Generation by Model Composition

Automated user-interface generation environments have been criticized for their failure to deliver rich and powerful interactive applications. To specify more powerful systems, designers need multiple, specialized modeling notations. The model composition problem is concerned with automatically deriving powerful, correct, and efficient user interfaces from multiple models specified in different notations. Solutions balance the advantages of separating code generation into specialized code generators with deep, model-specific knowledge against the correctness and efficiency obstacles that result from such separation. We present a solution that maximizes the advantages of separating code generation. In our approach, highly specialized, model-specific code generators synthesize run-time modules from individual models. We address the correctness and efficiency obstacles by formalizing composition mechanisms that code generators may assume and that are guaranteed by a run-time infrastructure. The mechanisms operate to support run-time module composition as conjunctions in the sense defined by Zave and Jackson